/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 *
 * A simple program that can be used to filter jobs for PostScript
 * printers. It's a cleaned up version of usg_iox, that I assume was
 * written by Richard Flood.  The most important addition includes some
 * simple processing of printer status reports, usually obtained when
 * \024 is sent to the printer. The returned status lines look like:
 *
 *
 *	%%[ status: idle; source serial 25 ]%%
 *	%%[ status: waiting; source serial 25 ]%%
 *	%%[ status: initializing; source serial 25 ]%%
 *	%%[ status: busy; source serial 25 ]%%
 *	%%[ status: printing; source serial 25 ]%%
 *	%%[ status: PrinterError: out of paper; source serial 25 ]%%
 *	%%[ status: PrinterError: no paper tray; source serial 25 ]%%
 *
 *
 * although the list isn't meant to be complete.
 *
 * Other changes to the original program include the addition of
 * options that let you select the tty line, baud rate, and printer
 * log file. The program seems to work reasonably well, at least for
 * our QMS PS-800 printer, but could still use some work.
 *
 * There were a couple of serious mistakes in the first few versions of
 * postcomm.  Both were made in setting up flow control in routine
 * initialize(). Setting the IXANY flag in c_iflag was wrong, and
 * often caused problems when the printer transmitted a spontaneous
 * status report, which always happens when the paper runs out.
 * Things were kludged up to get around the problems, but they were
 * never exactly right, and probably could never be guaranteed to work
 * 100%.
 *
 * The other mistake was setting the IXOFF flag, again in c_iflag.
 * Although I never saw deadlock in the original versions of postcomm,
 * it could happen.  Apparently the IXANY and IXOFF flags combined to
 * make that an unlikely event.  Anyway both flags should normally be
 * turned off to ensure reliable transmission of jobs.
 *
 * The implications of only setting IXON are obvious. Job transmission
 * should be reliable, but data returned by the printer over the tty
 * line may get lost. That won't cause problems in postcomm, but there
 * may be occasions when you want to run a job and recover data
 * generated by the printer. The -t option sets the IXOFF, IXANY, and
 * IXON flags in c_iflag and causes send() to be far more careful about
 * when data is sent to the printer. In addition anything not
 * recognized as a status report is written on stdout. It seems to
 * work reasonably well, but it's slow and may hang or have flow
 * control problems. Only use the -t option when it's absolutely
 * necessary. A small block size, like 512, should also help.
 *
 * Using two processes, one for reads and the other for writes, may
 * eventually be needed. For now postcomm seems to do a good job
 * transmitting data, and the -t option is probably acceptable for
 * those few jobs that need to recover data from the printer.
 *
 * A typical command line might be:
 *
 *	postcomm -L log -t <file1 > device
 *
 * where -L selects the printer log file and -t sends data from the
 * printer out to the printer.  If you don't choose a log file stderr
 * will be used and the information mailed or written to you.
 *
 */

#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>


# define	OFF		0
# define	ON		1
# define	TRUE		1
# define	FALSE		0
# define	FATAL		1
# define	NON_FATAL	0

#include "postcomm.h"		/* some special definitions */


char	*prog_name = "postcomm";	/* just for error messages */

int	debug = OFF;		/* debug flag */
int	ignore = OFF;		/* what's done for FATAL errors */


char	*block = NULL;		/* input file buffer */
int	blocksize = BLOCKSIZE;	/* and its size in bytes */
int	head = 0;		/* block[head] is the next character */
int	tail = 0;		/* one past the last byte in block[] */

char	mesg[BUFSIZE];		/* exactly what came back on ttyi */
char	sbuf[BUFSIZE];		/* for parsing the message */
int	next = 0;		/* next character goes in sbuf[next] */
Status	status[] = STATUS;	/* for converting status strings */

int	stopbits = 1;		/* number of stop bits */
int	tostdout = FALSE;	/* non-status stuff goes to stdout? */
int	curfile = 0;		/* only needed when tostdout is TRUE */

char	*postbegin = POSTBEGIN;	/* preceeds all the input files */

int	ttyi;			/* input */
int	ttyo = 2;		/* and output file descriptors */

FILE	*fp_log = stderr;	/* log file for data from the printer */



static void filter(void);
static int getstatus(int);
static void initialize(void);
static void options(int, char *[]);
static int readblock(int);
static int readline(void);
static void reset(void);
static int writeblock(void);

void
logit(char *mesg, ...)
{

/*
 *
 * Simple routine that's used to write a message to the log file.
 *
 */


    if (mesg != NULL)
    {
	va_list ap;

	va_start(ap, mesg);
	vfprintf(fp_log, mesg, ap);
	va_end(ap);
	fflush(fp_log);
    }

}   /* End of logit */





void
error(int kind, char *mesg, ...)
{


/*
 *
 * Called when we've run into some kind of program error. First *mesg is
 * printed using the control string arguments a?. Then if kind is FATAL
 * and we're not ignoring errors the program will be terminated.
 *
 * If mesg is NULL or *mesg is the NULL string nothing will be printed.
 *
 */


    if ( mesg != NULL  &&  *mesg != '\0' )  {
	va_list ap;

	fprintf(fp_log, "%s: ", prog_name);
	va_start(ap, mesg);
	vfprintf(fp_log, mesg, ap);
	va_end(ap);
	putc('\n', fp_log);
    }	/* End if */

    if ( kind == FATAL  &&  ignore == OFF )  {
	write(ttyo, "\003\004", 2);
	exit(1);
    }	/* End if */

}   /* End of error */





int
main(int argc, char *argv[])
{

/*
 *
 * A simple program that manages input and output for PostScript
 * printers. If you're sending a PostScript program that will be
 * returning useful information add the -ot option to the lp(1) command
 * line. Everything not recognized as a printer status report will go
 * to stdout. The -ot option should only be used when needed! It's slow
 * and doesn't use flow control properly, but it's probably the best
 * that can be done using a single process for reading and writing.
 */

    prog_name = argv[0];	/* really just for error messages */

    options(argc, argv);

    initialize();		/* Set printer up for printing */

    filter();

    reset();			/* wait 'til it's finished & reset it*/

    return (0);		/* everything probably went OK */

}   /* End of main */





static void
options(int argc, char *argv[])
{


    int		ch;			/* return value from getopt() */
    char	*names = "tB:L:P:DI";

    extern char	*optarg;		/* used by getopt() */

/*
 *
 * Reads and processes the command line options.  The -t option should
 * only be used when absolutely necessary.  It's slow and doesn't do
 * flow control properly.  Selecting a small block size (eg. 512 or
 * less) with with the -B option may help when you need the -t option.
 *
 */


    while ( (ch = getopt(argc, argv, names)) != EOF )
    {
	switch ( ch )
	{
	    case 't':		/* non-status stuff goes to stdout */
		    tostdout = TRUE;
		    break;

	    case 'B':		/* set the job buffer size */
		    if ((blocksize = atoi(optarg)) <= 0)
			blocksize = BLOCKSIZE;
		    break;

	    case 'L':			/* printer log file */
		    if ((fp_log = fopen(optarg, "w")) == NULL)
		    {
			fp_log = stderr;
			error(NON_FATAL, "can't open log file %s",
								optarg);
		    }	/* End if */
		    break;

	    case 'P':			/* initial PostScript program */
		    postbegin = optarg;
		    break;

	    case 'D':			/* debug flag */
		    debug = ON;
		    break;

	    case 'I':			/* ignore FATAL errors */
		    ignore = ON;
		    break;

	    case '?':			/* don't understand the option */
		    error(FATAL, "");
		    break;

	    default:			/* don't know what to do for ch */
		    error(FATAL, "missing case for option %c\n", ch);
		    break;

	}   /* End switch */

    }   /* End while */
}   /* End of options */





static void
initialize(void)
{
    if ((block = malloc(blocksize)) == NULL)
	error(FATAL, "no memory");

    ttyi = fileno(stdout);

    if ((ttyo = dup(ttyi)) == -1)
	error(FATAL, "can't dup file descriptor for stdout");

/*
 *
 * Makes sure the printer is in the
 * IDLE state before any real data is sent.
 *
 */


    logit("printer startup\n");

    while ( 1 )
	switch (getstatus(1))
	{
	    case IDLE:
		    if (postbegin != NULL)
			write(ttyo, postbegin, strlen(postbegin));
		    else
			write(ttyo, "\n", 1);
		    return;

	    case WAITING:
	    case BUSY:
	    case ERROR:
		    write(ttyo, "\003\004", 2);
		    sleep(1);
		    break;

	    case FLUSHING:
		    write(ttyo, "\004", 1);
		    sleep(1);
		    break;

	    case PRINTERERROR:
	    case INITIALIZING:
		    sleep(15);
		    break;

	    case DISCONNECT:
		    /* talk to spooler w/S_FAULT_ALERT */
		    error(FATAL, "printer appears to be offline");
		    break;

	    default:
		    sleep(1);
		    break;

	}   /* End switch */

}   /* End of initialize */





static void
filter(void)
{
    static int	wflag = 0;	/* nonzero if we've written a block */
    int		fd_in = fileno(stdin);

/*
 *
 * Responsible for sending the next file to the printer.
 * Most of the hard stuff is done in getstatus() and readline().
 * All this routine really does is control what happens for the
 * different printer states.
 *
 */


    logit("sending file\n");

    curfile++;

    while (readblock(fd_in))
	switch (getstatus(0))
	{
	    case WAITING:
		    writeblock();
		    wflag = 1;
		    break;

	    case BUSY:
	    case PRINTING:
	    case PRINTERERROR:
		    if (tostdout == FALSE)
		    {
			writeblock();
			wflag = 1;
		    }
		    else
			sleep(1);
		    break;

	    case UNKNOWN:
		    if (tostdout == FALSE)
		    {
			writeblock();
			wflag = 1;
		    }
		    break;

	    case NOSTATUS:
		    if (tostdout == FALSE)
		    {
			if (wflag)
			    writeblock();
		    }
		    else
			sleep(1);
		    break;

	    case IDLE:
		    if (wflag)
			error(FATAL, "printer is idle");
		    write(ttyo, "\n", 1);
		    break;

	    case ERROR:
		    fprintf(stderr, "%s", mesg);	/* for csw */
		    error(FATAL, "PostScript error");
		    break;

	    case FLUSHING:
		    error(FATAL, "PostScript error");
		    break;

	    case INITIALIZING:
		    error(FATAL, "printer booting");
		    break;

	    case DISCONNECT:
		    error(FATAL, "printer appears to be offline");
		    break;

	}   /* End switch */

}   /* End of print */





static int
readblock(int fd_in)
    /* current input file */
{

/*
 *
 * Fills the input buffer with the next block, provided we're all done
 * with the last one.  Blocks from fd_in are stored in array block[].
 * Head is the index of the next byte in block[] that's supposed to go
 * to the printer.   tail points one past the last byte in the current
 * block.  head is adjusted in writeblock() after each successful
 * write, while head and tail are reset here each time a new block is
 * read.  Returns the number of bytes left in the current block.   Read
 * errors cause the program to abort.
 *
 */

    if (head >= tail)
    {		/* done with the last block */
	if ((tail = read(fd_in, block, blocksize)) == -1)
	    error(FATAL, "error reading input file");
	head = 0;
    }

    return(tail - head);

}   /* End of readblock */





static int
writeblock(void)
{
    int		count;		/* bytes successfully written */

/*
 *
 * Called from send() when it's OK to send the next block to the
 * printer. head is adjusted after the write, and the number of bytes
 * that were successfully written is returned to the caller.
 *
 */


    if ((count = write(ttyo, &block[head], tail - head)) == -1)
	error(FATAL, "error writing to stdout");
    else
	if (count == 0)
	    error(FATAL, "printer appears to be offline");

    head += count;
    return(count);
}   /* End of writeblock */





static int
getstatus(int t)
    /* sleep time after sending '\024' */
{
    char	*state;		/* new printer state - from sbuf[] */
    int		i;		/* index of new state in status[] */
    static int	laststate = NOSTATUS;
				/* last state we found out about */

/*
 *
 * Sends a status request to the printer and tries to read the response.
 * If an entire line is available readline() returns TRUE and the
 * string in sbuf[] is parsed and converted into an integer code that
 * represents the printer's state.  If readline() returns FALSE,
 * meaning an entire line wasn't available, NOSTATUS is returned.
 *
 */

    if (readline() == TRUE)
    {
	state = sbuf;

	if (strncmp(sbuf, "%%[", 3) == 0)
	{
	    strtok(sbuf, " ");		/* skip the leading "%%[ " */
	    if (strcmp(state = strtok(NULL, " :;"), "status") == 0)
		state = strtok(NULL, " :;");
	}

	for (i = 0; status[i].state != NULL; i++)
	    if (strcmp(state, status[i].state) == 0)
		break;

	if (status[i].val != laststate || debug == ON)
	    logit("%s", mesg);

	if (tostdout == TRUE && status[i].val == UNKNOWN && curfile > 0)
	    fprintf(stdout, "%s", mesg);

	return(laststate = status[i].val);
    }	/* End if */

    if ( write(ttyo, "\024", 1) != 1 )
	error(FATAL, "printer appears to be offline");

    if ( t > 0 )
	sleep(t);

    return(NOSTATUS);

}   /* End of getstatus */





static void
reset(void)
{
    int		sleeptime = 15;		/* for 'out of paper' etc. */
    int		senteof = FALSE;

/*
 *
 * We're all done sending the input files, so we'll send an EOF to the
 * printer and wait until it tells us it's done.
 *
 */


    logit("waiting for end of job\n");

    while (1)
    {
	switch (getstatus(2))
	{
	    case WAITING:
		write(ttyo, "\004", 1);
		senteof = TRUE;
		sleeptime = 15;
		break;

	    case ENDOFJOB:
		if (senteof == TRUE)
		{
		    logit("job complete\n");
		    return;
		}
		sleeptime = 15;
		break;

	    case BUSY:
	    case PRINTING:
		sleeptime = 15;
		sleep(1);
		break;

	    case PRINTERERROR:
		sleep(sleeptime++);
		break;

	    case ERROR:
		fprintf(stderr, "%s", mesg);	/* for csw */
		error(FATAL, "PostScript error");
		return;

	    case FLUSHING:
		error(FATAL, "PostScript error");
		return;

	    case IDLE:
		error(FATAL, "printer is idle");
		return;

	    case INITIALIZING:
		error(FATAL, "printer booting");
		return;

	    case DISCONNECT:
		error(FATAL, "printer appears to be offline");
		return;

	    default:
		sleep(1);
		break;

	}   /* End switch */

	if (sleeptime > 60)
	    sleeptime = 60;

    }	/* End while */

}   /* End of reset */









static int
readline(void)
{
    char	ch;			/* next character from ttyi */
    int		n;			/* read() return value */

/*
 *
 * Reads the printer's tty line up to a newline (or EOF) or until no
 * more characters are available. As characters are read they're
 * converted to lower case and put in sbuf[next] until a newline (or
 * EOF) are found. The string is then terminated with '\0', next is
 * reset to zero, and TRUE is returned.
 *
 */


    while ((n = read(ttyi, &ch, 1)) != 0)
    {
	if (n < 0)
	    error(FATAL, "error reading stdout");
	mesg[next] = ch;
	sbuf[next++] = tolower(ch);
	if (ch == '\n'  ||  ch == '\004')
	{
	    mesg[next] = sbuf[next] = '\0';
	    if (ch == '\004')
		sprintf(sbuf, "%%%%[ status: endofjob ]%%%%\n");
	    next = 0;
	    return(TRUE);
	}   /* End if */
    }	/* End while */

    return(FALSE);

}   /* End of readline */
